home *** CD-ROM | disk | FTP | other *** search
/ Nautilus 1992 July / Nautilus-3-8 / Nautilus-3-8.bin / Tools & Utilities / Techy Stuff / Source ƒ / ASM 2.0 ƒ / match.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-15  |  20.7 KB  |  970 lines
  1. #include <stdio.h>
  2. #include "as.h"
  3. #include "table.h"
  4. #include "lookup.h"
  5.  
  6. #define MAXEA   30
  7.  
  8. struct ea Eas[MAXEA] = {0};   /* parsed ea's */
  9. extern char *Optr;
  10. extern char *skip_white();
  11. extern int Debug;
  12. extern int Size;
  13. extern int Fwdsize;
  14. extern int Force;
  15.  
  16. char *eanames[] = {
  17.     "---", "Dn", "An", "(An)", "(An)+", "-(An)",
  18.     "indexed", "expr", "#imm", "pc-indexed",
  19.     "Dn:Dn", "(Rn):(Rn)", "RList", "{Dn/#:Dn/#}",
  20.     "Cn", "CCR", "SR", "FPn", "FPCn", "FPList",
  21.     "FPn:FPn", "FPClist", "{Dn}", "{#}", "Pn", "String",
  22.     "Rn", "AnyEA", "CtlEA", "AltMem", "DataAlt", "Alterable",
  23.     "Data", "--CtlAlt", "Ctl++", "CtlAlt", "Memory", "Dn/Cn/Mask",
  24.     "ExprList",
  25.     0
  26.     };
  27.  
  28. /*
  29.  *      tmpl_match --- match size and operands of instruction
  30.  *
  31.  *      Given a pointer to N entries in the template table, scan
  32.  *      and try to match the operand field of the line with one of
  33.  *      them.  Return NULL if nothing matches, otherwise a pointer
  34.  *      to the matching entry.
  35.  *
  36.  *      A successful match will leave the processed operands in the Eas
  37.  *      array.  The first unused entry in Eas will have a type of EMPTY.
  38.  *
  39.  *      To be a successful match, the template must first match the
  40.  *      size field.  After this, if the type is EMPTY the match
  41.  *      is successful.  Also, if the type is MULTI, an open ended
  42.  *      number of EXPR's will be scanned.
  43.  */
  44. struct tmpl *
  45. tmpl_match(p,n)
  46. struct tmpl *p;         /* first one to test */
  47. int n;                  /* number of templates to check */
  48. {
  49.     register struct ea *e = Eas;
  50.     int i;
  51.  
  52.     if( Size&p->sizes ){    /* quick test for MULTI/EMPTY templates */
  53.         if(p->modes[0] == EMPTY )
  54.             return(p);
  55.         if(p->modes[0] == MULTI ){
  56.             do_multi();
  57.             return(p);
  58.             }
  59.         }
  60.  
  61.     /* otherwise there are 1 to 4 operands */
  62.     Eas[0].type = Eas[1].type = Eas[2].type = Eas[3].type = EMPTY;
  63.     scanea(e++);
  64.     if( *Optr == ',' || *Optr=='{' ){
  65.         if(*Optr==',')
  66.             Optr++;
  67.         scanea(e++);
  68.         if( *Optr == ',' || *Optr=='{' ){
  69.             if(*Optr==',')
  70.                 Optr++;
  71.             scanea(e++);
  72.             if( *Optr == ',' || *Optr=='{' ){
  73.                 if(*Optr==',')
  74.                     Optr++;
  75.                 scanea(e++);
  76.                 }
  77.             }
  78.         }
  79.     /* 1-4 ea's now in Eas */
  80. if(Debug&MATCH){
  81.     printf("Match:");
  82.     for(i=0;i<4;i++)
  83.         printf(" %s",eanames[ Eas[i].type ]);
  84.     printf("\n");
  85.     }
  86.  
  87.     while(n--){
  88.         if( (Size&p->sizes) &&
  89.             eamatch(p->modes[0],Eas[0].type) &&
  90.             eamatch(p->modes[1],Eas[1].type) &&
  91.             eamatch(p->modes[2],Eas[2].type) &&
  92.             eamatch(p->modes[3],Eas[3].type) )
  93.             return(p);
  94.         p++;
  95.         }
  96.     return(NULL);
  97. }
  98.  
  99. #define sDN     (1<<DN)
  100. #define sAN     (1<<AN)
  101. #define sANI    (1<<ANI)
  102. #define sPREDEC (1<<PREDEC)
  103. #define sPSTINC (1<<PSTINC)
  104. #define sINDEX  (1<<INDEX)
  105. #define sEXPR   (1<<EXPR)
  106. #define sIMMED  (1<<IMMED)
  107. #define sPCINDEX (1<<PCINDEX)
  108. #define sCN     (1<<CN)
  109.  
  110. /*
  111.  *      eatab --- bit map of legal modes for composite EA types
  112.  */
  113. int eatab[] = {
  114.     sDN|sAN,                                                   /* Rn */
  115.     sDN|sAN|sANI|sPREDEC|sPSTINC|sINDEX|sEXPR|sIMMED|sPCINDEX, /* anyea */
  116.         sANI|                sINDEX|sEXPR|       sPCINDEX, /* control */
  117.         sANI|sPREDEC|sPSTINC|sINDEX|sEXPR,                 /* altmem */
  118.     sDN|    sANI|sPREDEC|sPSTINC|sINDEX|sEXPR,                 /* datalt */
  119.     sDN|sAN|sANI|sPREDEC|sPSTINC|sINDEX|sEXPR,                 /* alter */
  120.     sDN|    sANI|sPREDEC|sPSTINC|sINDEX|sEXPR|sIMMED|sPCINDEX, /* data */
  121.         sANI|sPREDEC|        sINDEX|sEXPR,                 /* caltpr */
  122.         sANI|        sPSTINC|sINDEX|sEXPR|       sPCINDEX, /* ctlpst */
  123.         sANI|                sINDEX|sEXPR,                 /* ctlalt */
  124.         sANI|sPREDEC|sPSTINC|sINDEX|sEXPR|sIMMED|sPCINDEX, /* memory */
  125.     sDN|sEXPR|sCN,                                             /* PEA1  */
  126.     0                                                          /* multi */
  127.     };
  128.  
  129. /*
  130.  *      eamatch --- match a general ea class against the specific operand
  131.  *
  132.  *      gen is taken from the template, and spec comes from
  133.  *      the type field of the scanned ea.  Gen classes less than
  134.  *      RN are basic types, classes RN and above are composite
  135.  *      types.  This routine will break if there are more basic
  136.  *      types than bits in an int.
  137.  */
  138. eamatch(gen,spec)
  139. int gen;        /* general addressing mode class */
  140. int spec;       /* specific ea for an operand */
  141. {
  142.     if(gen<RN) return( gen==spec );
  143.     return( eatab[gen-RN] & (1<<spec));
  144. }
  145.  
  146. /*
  147.  *      scanea --- convert next item in Operand to ea structure
  148.  */
  149. scanea(e)
  150. register struct ea *e;
  151. {
  152.     register char *saveoptr = Optr+1; /* in case we need to backup */
  153.  
  154.     e->type = EMPTY;  e->itype = EMPTY;
  155.     e->reg = e->const = e->reg2 = e->const2 = 0;
  156.     e->stat = e->br_sup = e->stat2 = e->xn_sup = 0;
  157.     e->force = e->siz = e->scl = 0;
  158.  
  159.     switch(*Optr++){
  160.     case '#':       /* looks like immediate */
  161.         if( eval(&e->const) != SYM )
  162.             error("Expected expression");
  163.         else
  164.             e->type = IMMED;
  165.         break;
  166.     case '{':       /* FIELD,DYNK,STATK */
  167.         switch( eval(&e->const) ){
  168.         case DREG:
  169.             e->type = DYNK;
  170.             e->reg = e->const;
  171.             break;
  172.         case SYM:
  173.             e->type = STATK;
  174.             e->stat = 1;   /* in case it turns out to be FIELD */
  175.             break;
  176.         default:
  177.             error("Bad specifier");
  178.             break;
  179.             }
  180.         if(*Optr== ':' ){       /* it's a field specifier */
  181.             Optr++;
  182.             switch( eval(&e->const2) ){
  183.             case DREG:
  184.                 e->reg2 = e->const2;
  185.                 break;
  186.             case SYM:
  187.                 e->stat2 = 1;
  188.                 break;
  189.             default:
  190.                 error("Bad specifer");
  191.                 break;
  192.                 }
  193.             if( *Optr++ == '}' )
  194.                 e->type = FIELD;
  195.             else{
  196.                 error("Missing } on bit field spec.");
  197.                 e->type = EMPTY;
  198.                 }
  199.             }
  200.         else if( *Optr == '}' )
  201.             Optr++;
  202.         else
  203.             warn("Missing }?");
  204.         break;
  205.     case '\(':       /* could be almost anything */
  206.         if( *Optr == '[' ){
  207.             Optr++;
  208.             oh_shit(e);
  209.             break;
  210.             }
  211.         switch( eval(&e->const) ){
  212.         case AREG:
  213.             if( *Optr == '\)' ){
  214.                 e->reg = e->const;
  215.                 Optr++;
  216.                 e->type = ANI;
  217.                 if( *Optr== '+' ){
  218.                     Optr++;
  219.                     e->type = PSTINC;
  220.                     }
  221.                 else if( *Optr == ':'){  /* possibly RPAIR */
  222.                     e->type = RPAIR;
  223.                     Optr++;
  224.                     if( *Optr++ == '\(' ){
  225.                         e->stat = 1;
  226.                         e->stat2 = eval(&e->reg2);
  227.                         if( *Optr++ != '\)' ){
  228.                             error("Bad reg. pair");
  229.                             e->type = EMPTY;
  230.                             }
  231.                         else if( e->stat2 == AREG )
  232.                             e->stat2 = 1;
  233.                         else if( e->stat2 == DREG )
  234.                             e->stat2 = 0;
  235.                         else{
  236.                             error("Bad type in register pair");
  237.                             e->type = EMPTY;
  238.                             }
  239.                         }
  240.                     else{
  241.                         error("Expected Reg. pair");
  242.                         e->type = EMPTY;
  243.                         }
  244.                     }
  245.                 }
  246.             else if( index(",.*",*Optr) ){ /* possibly indexed */
  247.                 Optr = saveoptr; /* backup to An again */
  248.                 e->const = 0;    /* zero base displacement */
  249.                 do_indexed(e);
  250.                 }
  251.             else{
  252.                 error("Expected '\)'");
  253.                 e->type = EMPTY;
  254.                 }
  255.             break;
  256.         case DREG:      /* register pair or (Dn) indexing */
  257.             if( *Optr == '\)' &&
  258.                 *(Optr+1) == ':' &&
  259.                 *(Optr+2) == '\(' ){
  260.                 Optr += 3;
  261.                 e->type = RPAIR;
  262.                 e->reg = e->const;
  263.                 e->stat2 = eval(&e->reg2);
  264.                 if( *Optr++ != '\)' ){
  265.                     error("Expected '\)'");
  266.                     e->type == EMPTY;
  267.                     }
  268.                 else if( e->stat2 == DREG )
  269.                     e->stat2 = 0;
  270.                 else if( e->stat2 == AREG )
  271.                     e->stat2 = 1;
  272.                 else{
  273.                     error("Bad register pair");
  274.                     e->type == EMPTY;
  275.                     }
  276.                 }
  277.             else{
  278.                 Optr = saveoptr;
  279.                 e->const = 0;    /* zero base displacement */
  280.                 do_indexed(e);
  281.                 }
  282.             break;
  283.         case SYM:       /* could be EXPR,INDEX or PCINDEX */
  284.             if( *Optr == '\)' ){
  285.                 Optr++;
  286.                 e->type = EXPR;
  287.                 e->force = Force;
  288.                 e->siz = optsize(e->const);/* .[WL] allowed */
  289.                 }
  290.             else if( *Optr == ',' ){
  291.                 Optr++;
  292.                 do_indexed(e);
  293.                 }
  294.             else
  295.                 error("Expression syntax");
  296.             break;
  297.         case ZAREG:
  298.         case ZDREG:
  299.         case PC:
  300.         case ZPC:
  301.             Optr = saveoptr;
  302.             e->const = 0;    /* supressed base register */
  303.             do_indexed(e);
  304.             break;
  305.         default:
  306.             error("Expression syntax");
  307.             break;
  308.             }
  309.         break;
  310.     case '-':       /* could be -(An) */
  311.         if(*Optr == '\(' ){
  312.             Optr++;
  313.             if( eval(&e->reg) == AREG && (*Optr++ == '\)') )
  314.                 e->type = PREDEC;
  315.             else
  316.                 error("Expected Address register");
  317.             break;
  318.             }
  319.         /* fall through, it might be a negative expr. */
  320.     default:        /* something starting with an expression */
  321.         Optr--;
  322.         switch( eval(&e->const) ){
  323.         case DREG:
  324.             e->type = DN;
  325.             e->reg = e->const;
  326.             checkpair(e);
  327.             checklist(e);
  328.             break;
  329.         case AREG:
  330.             e->type = AN;
  331.             e->reg = e->const;
  332.             checkpair(e);
  333.             checklist(e);
  334.             break;
  335.         case CREG:
  336.             e->type = CN;
  337.             e->reg = e->const;
  338.             break;
  339.         case PREG:
  340.             e->type = PN;
  341.             e->reg = e->const;
  342.             break;
  343.         case FREG:
  344.             e->type = FN;
  345.             e->reg = e->const;
  346.             checkpair(e);
  347.             checklist(e);
  348.             break;
  349.         case FCREG:
  350.             e->type = FCN;
  351.             e->reg = e->const;
  352.             checklist(e);
  353.             break;
  354.         case SREG:
  355.             e->type = e->const;
  356.             break;
  357.         case SYM:
  358.             if( *Optr == '\(' ){
  359.                 Optr++;
  360.                 do_indexed(e);
  361.                 }
  362.             else{
  363.                 e->type = EXPR;
  364.                 e->force = Force;
  365.                 e->siz = optsize(e->const);
  366.                 }
  367.             break;
  368.         case QSTR:
  369.             e->type = STRING;
  370.             break;
  371.         default:
  372.             error("Expression syntax");
  373.             break;
  374.             }
  375.         break;
  376.         }
  377. }
  378.  
  379. /*
  380.  *      do_multi --- scan multiple EXPR/STRING ea's
  381.  */
  382. do_multi()
  383. {
  384.     int eatotal = 0;
  385.     register struct ea *e = Eas;
  386.  
  387.     do{
  388.         Optr = skip_white(Optr);
  389.         scanea(e);
  390.         if( e->type == EXPR || e->type == STRING ){
  391.             eatotal++;
  392.             e++;
  393.             }
  394.         else{
  395.             error("Expected expression");
  396.             break;
  397.             }
  398.     }while(eatotal<MAXEA && *Optr++==',');
  399.     e->type = EMPTY;        /* end+1 of valid ea's is marked EMPTY */
  400. }
  401.  
  402. /*
  403.  *      optsize --- allow optional .W or .L
  404.  *
  405.  *      A .W or .L following an expression will determine the size of
  406.  *      the most recent expression evaluation.  If there is no following
  407.  *      size specification, the assembler will choose the size based
  408.  *      on the Force (forward ref) flag, and/or the value of the expression.
  409.  */
  410. optsize(v)
  411. int v;  /* value */
  412. {
  413.     int s;
  414.  
  415.     if( *Optr == '.' ){
  416.         switch( *(Optr+1) ){
  417.         case 'w':
  418.         case 'W':  s = W; Optr += 2; break;
  419.         case 'l':
  420.         case 'L':  s = L; Optr += 2; break;
  421.         default:
  422.             if(Force || v<MINWORD || v>MAXWORD)
  423.                 s = L;
  424.             else
  425.                 s = Fwdsize;
  426.             }
  427.         }
  428.     else if(Force || v<MINWORD || v>MAXWORD )
  429.         s = L;
  430.     else
  431.         s = Fwdsize;
  432.     return(s);
  433. }
  434.  
  435. /*
  436.  *      optscale --- allow optional *1, *2, *4 or *8
  437.  */
  438. optscale()
  439. {
  440.     int s = 0;
  441.  
  442.     if( *Optr == '*' )
  443.     switch( *(Optr+1) ){
  444.     case '1':  s = 0; Optr += 2; break;
  445.     case '2':  s = 1; Optr += 2; break;
  446.     case '4':  s = 2; Optr += 2; break;
  447.     case '8':  s = 3; Optr += 2; break;
  448.         }
  449.     return(s);
  450. }
  451.  
  452. /*
  453.  *      do_indexed --- handle simple indexed addressing cases
  454.  *
  455.  *      The first part of an indexed addressing mode has been
  456.  *      seen.  Either 'SYM(' or '(SYM,' has been evaluated,
  457.  *      with the value of SYM placed in e->const.  The remaining
  458.  *      part should be either 'AN)' or 'AN,RN[.siz][*scale])'.
  459.  *      AN could also be PC at this point.
  460.  *
  461.  *    For 'AN)' or 'PC)', the selected mode will be D16AN if the
  462.  *    SYM part is not a forward ref, and will fit in a 16-bit
  463.  *    field.  Otherwise, the FULL format is used with xn_sup set.
  464.  *
  465.  *    If DREG,ZAREG,ZDREG or ZPC is seen, it is assumed that
  466.  *    the base register is to be supressed.  Also, if AN is
  467.  *    followed by a '.' or '*', we assume that it is the index
  468.  *    register, not the base.
  469.  */
  470. do_indexed(e)
  471. struct ea *e;
  472. {
  473.     char *saveoptr = Optr;    /* in case it's not what I expect */
  474.     extern int Pc;
  475.  
  476.     e->type = INDEX;    /* the common case */
  477.     switch( eval(&e->reg) ){
  478.     case AREG:
  479.         if(*Optr == '\)' ){
  480.             Optr++;
  481.             if( e->force || 
  482.                 e->const < MINWORD ||
  483.                 e->const > MAXWORD){
  484.                 e->itype = FULL;
  485.                 e->bdsiz = 3;    /* 32 bits */
  486.                 e->xn_sup = 1;
  487.                 e->odsiz = 0;    /* empty */
  488.                 }
  489.             else
  490.                 e->itype = D16AN;
  491.             return;
  492.             }
  493.         if( *Optr == ',')
  494.             Optr++;        /* must be the base reg */
  495.         else{
  496.             Optr = saveoptr;
  497.             e->br_sup = 1;    /* assume we just saw Xn */
  498.             }
  499.         break;
  500.     case ZPC:
  501.         e->br_sup = 1;    /* supress PC */
  502.     case PC:
  503.         e->type = PCINDEX;
  504.         if(*Optr == '\)' ){
  505.             Optr++;
  506.             if( e->br_sup )
  507.                 error("illegal use of ZPC");
  508.             if( e->force || 
  509.                 (e->const-Pc) < MINWORD ||
  510.                 (e->const-Pc) > MAXWORD){
  511.                 e->itype = FULL;
  512.                 e->bdsiz = 3;    /* 32 bits */
  513.                 e->xn_sup = 1;
  514.                 e->odsiz = 0;    /* empty */
  515.                 }
  516.             else
  517.                 e->itype = D16AN;
  518.             return;
  519.             }
  520.         if( *Optr++ != ',')
  521.             error("Expected ,");
  522.         break;
  523.     case DREG:
  524.     case ZAREG:
  525.     case ZDREG:
  526.         Optr = saveoptr;    /* backup to let do_xn handle it */
  527.         e->br_sup = 1;        /* supress base register */
  528.         break;
  529.     default:
  530.         e->type = EMPTY;
  531.         error("Bad indexed addressing syntax");
  532.         return;
  533.         }
  534.     do_xn(e);
  535.     /* Try to pick the format based on the base displacement */
  536.     /* If it's a forward ref, won't fit within a byte, */
  537.     /* or has either the base or index register supressed */
  538.     /* switch to the FULL format */
  539.     if( e->force || e->xn_sup || e->br_sup 
  540.         || e->const <MINBYTE || e->const >MAXBYTE){
  541.         if( e->force || e->const <MINWORD || e->const>MAXWORD)
  542.             e->bdsiz = 3;    /* force 32-bit displacement */
  543.         else if( e->const != 0)
  544.             e->bdsiz = 2;    /* try 16-bit displacement */
  545.         else
  546.             e->bdsiz = 1;    /* no displacement at all */
  547.         e->odsiz = 0;    /* and supressed outer displacement */
  548.         e->itype = FULL;
  549.         }
  550.     else
  551.         e->itype = BRIEF;
  552.     if( *Optr++ != '\)')
  553.         error("Expected )");
  554. }
  555.  
  556. /*
  557.  *      do_xn --- collect Xn.siz*scl (sets reg2,stat2,siz,scl,xn_sup)
  558.  */
  559. do_xn(e)
  560. struct ea *e;
  561. {
  562.     switch( eval(&e->reg2) ){
  563.     case DREG:
  564.         break;
  565.     case ZDREG:
  566.         e->xn_sup = 1;
  567.         break;
  568.     case AREG:
  569.         e->stat2 = 1;
  570.         break;
  571.     case ZAREG:
  572.         e->stat2 = 1;
  573.         e->xn_sup = 1;
  574.         break;
  575.     default:
  576.         error("Index register");
  577.         e->type = EMPTY;
  578.         break;
  579.         }
  580.     e->siz = optsize(0);
  581.     e->scl = optscale();
  582. }
  583.  
  584. /*
  585.  *      checkpair --- see if register name is followed by :reg
  586.  *
  587.  *      If the next char is : and the next item is the same type
  588.  *      as the one already scanned, change the type of this ea
  589.  *      to PAIR.  Only Dn, and FPn pairs are currently allowed.
  590.  */
  591. checkpair(e)
  592. struct ea *e;
  593. {
  594.     if( *Optr == ':' ){
  595.         Optr++;
  596.         switch( eval(&e->reg2) ){
  597.         case DREG:
  598.             if( e->type == DN )
  599.                 e->type = DPAIR;
  600.             else
  601.                 error("Dn pair expected");
  602.             break;
  603.         case FREG:
  604.             if( e->type == FN )
  605.                 e->type = FPAIR;
  606.             else
  607.                 error("FPn pair expected");
  608.             break;
  609.         default:
  610.             error("Register pair?");
  611.             break;
  612.             }
  613.         }
  614. }
  615.  
  616. /*
  617.  *      checklist --- see if register name is beginning of a reg. list
  618.  *
  619.  *      If the next char is - or /, then this is a register list type
  620.  *      of field.  If the next char is - then the next item must
  621.  *      be of the same type, and have a register value greater than
  622.  *      the first reg.  If the next char is / then the next item
  623.  *      may be any legal register name for the class.  Currently,
  624.  *      register lists may be constructed from (AN,DN), FPN and FCLIST
  625.  *      type items.
  626.  *
  627.  *      A successful match will leave the e->reg value with a
  628.  *      bit map of the registers specified.
  629.  */
  630. checklist(e)
  631. struct ea *e;
  632. {
  633.     int mask = 0;
  634.     int i;
  635.  
  636.     if( *Optr!= '-' && *Optr != '/' )
  637.         return;
  638.  
  639.     while( *Optr=='-' || *Optr=='/' ){
  640.         mask |= regbit(e->type,e->reg); /* add current reg to mask */
  641.         if( *Optr++ == '/' ){
  642.             switch( eval(&e->reg) ){
  643.             case DREG:
  644.                 if( e->type == DN )
  645.                     ;
  646.                 else if(e->type == AN )
  647.                     e->type = DN;
  648.                 else
  649.                     error("Register list");
  650.                 break;
  651.             case AREG:
  652.                 if( e->type == AN )
  653.                     ;
  654.                 else if(e->type == DN )
  655.                     e->type = AN;
  656.                 else
  657.                     error("Register list");
  658.                 break;
  659.             case FREG:
  660.                 if( e->type != FN )
  661.                     error("Register list");
  662.                 break;
  663.             case FCREG:
  664.                 if( e->type != FCN )
  665.                     error("Register list");
  666.                 break;
  667.             default:
  668.                 error("Register list");
  669.                 break;
  670.                 }
  671.             }
  672.  
  673.         else{   /* range of regs */
  674.             switch( eval(&e->reg2) ){
  675.             case AREG:
  676.                 if( e->type != AN )
  677.                     error("Register list");
  678.                 break;
  679.             case DREG:
  680.                 if( e->type != DN )
  681.                     error("Register list");
  682.                 break;
  683.             case FREG:
  684.                 if( e->type != FN )
  685.                     error("Register list");
  686.                 break;
  687.             case FCREG:
  688.                 if( e->type != FCN )
  689.                     error("Register list");
  690.                 break;
  691.             default:
  692.                 error("Register list");
  693.                 break;
  694.                 }
  695.             if( e->reg2 > e->reg )
  696.                 for(i= e->reg; i <= e->reg2; i++)
  697.                     mask |= regbit(e->type,i);
  698.             else
  699.                 for(i= e->reg2; i <= e->reg; i++)
  700.                     mask |= regbit(e->type,i);
  701.             }
  702.         }
  703.  
  704.     mask |= regbit(e->type,e->reg); /* pickup last reg */
  705.     switch(e->type){
  706.     case DN:
  707.     case AN:
  708.         e->type = RLIST;
  709.         break;
  710.     case FN:
  711.         e->type = FLIST;
  712.         break;
  713.     case FCN:
  714.         e->type = FCLIST;
  715.         break;
  716.     case EMPTY: /* there was a problem somewhere */
  717.         break;
  718.     default:
  719.         fatal("Botch in checklist");
  720.         }
  721.     e->reg = mask;
  722. }
  723.  
  724. /*
  725.  *      regbit --- convert register number to bit position
  726.  */
  727. regbit(type,reg)
  728. int type;
  729. int reg;
  730. {
  731.     switch(type){
  732.     case AN:
  733.         reg += 8;
  734.     case DN:
  735.     case FN:
  736.         return( 1 << reg);
  737.     case FCN:
  738.         return(reg);
  739.     default:
  740.         fatal("Botch in regbit");
  741.         }
  742. }
  743.  
  744. /*
  745.  *      oh_shit --- handle indexed indirect addressing
  746.  *
  747.  *      The first part of an indexed indirect addressing mode has
  748.  *      been seen: '(['.  Parse the rest and put it in an ea structure.
  749.  */
  750. oh_shit(e)
  751. struct ea *e;
  752. {
  753.     struct {
  754.         int     i_type;
  755.         int     i_val;
  756.         int     i_force;        /* set if i_val is fwd ref */
  757.         int     i_siz;
  758.         int     i_scale;
  759.     } idx[4];
  760.  
  761.     register int i = -1;
  762.     register int iflag = -1; /* ] appears after iflag'th item */
  763.     int j;
  764.     int     base,xreg;
  765.     extern char *tnames[];
  766.  
  767.     while( *Optr && (*Optr != '\)') ){
  768.         Optr = skip_white(Optr);
  769.         if( *Optr == ']' ){
  770.             iflag = i;    /* remember were ] was placed */
  771.             Optr++;
  772.             }
  773.         else if( *Optr == ',')
  774.             Optr++;
  775.         else{
  776.             i++;
  777.             if( i > 3 )
  778.                 break;  /* too many items */
  779.             idx[i].i_type = eval(&idx[i].i_val);
  780.             idx[i].i_force = Force;
  781.             idx[i].i_siz = optsize(idx[i].i_val);
  782.             idx[i].i_scale = optscale();
  783.             }
  784.         }
  785.  
  786. #ifdef M68020
  787. if(Debug&XDEBUG){
  788.     printf("Indir:");
  789.     for(j=0;j<=i;j++)
  790.         printf(" (%s %x %x %x)",tnames[idx[j].i_type],idx[j].i_val,
  791.                     idx[j].i_siz,idx[j].i_scale);
  792.     printf(" iflag:%d\n",iflag);
  793.     }
  794.  
  795.     /* some sanity checks */
  796.     if( (*Optr++ != '\)') || iflag<0 || iflag>2 || i<0 || i>3){
  797.         error("Indexed indirect syntax");
  798.         e->type = EMPTY;
  799.         return;
  800.         }
  801.  
  802.     /* start with everything supressed */
  803.     e->type  = INDEX;
  804.     e->itype = FULL;
  805.     e->reg   = 0;
  806.     e->reg2  = 0;
  807.     e->stat2 = 0;   /* default is DREG */
  808.     e->const = 0;
  809.     e->const2= 0;
  810.     e->odsiz = 1;
  811.     e->bdsiz = 1;
  812.     e->siz   = 0;   /* word indexing */
  813.     e->scl   = 0;   /* *1 scaling */
  814.     e->br_sup   = 1;
  815.     e->xn_sup  = 1;
  816.     e->prepst= 0;   /* pre indexing */
  817.     e->force = 0;
  818.     e->force2= 0;
  819.  
  820.     if( idx[0].i_type == SYM ){  /* base displacement */
  821.         e->bdsiz = (idx[0].i_siz==L ? 3 : 2);
  822.         e->const = idx[0].i_val;
  823.         e->force = idx[0].i_force;
  824.         base = 1;
  825.         }
  826.     else
  827.         base = 0;
  828.  
  829.     if( i>0 && idx[i].i_type == SYM){ /* outer displacement */
  830.         e->odsiz = (idx[i].i_siz==L ? 3 : 2);
  831.         e->const2 = idx[i].i_val;
  832.         e->force2 = idx[i].i_force;
  833.         xreg = i-1;
  834.         }
  835.     else
  836.         xreg = i;
  837.  
  838.     /* Possible base and outer displacements have been stripped off */
  839.     /* base and xreg point to what's left */
  840.  
  841.     if( xreg < base){       /* nothing left, must be mem indir */
  842.         if( iflag != 0 )
  843.              error("Memory Indirect syntax");
  844.         return;
  845.         }
  846.  
  847.     if( xreg != base ){     /* [An,Xn] or [An],Xn */
  848.         switch( idx[base].i_type ){
  849.         case AREG:
  850.              e->br_sup = 0;
  851.         case ZAREG:
  852.              e->reg = idx[base].i_val;
  853.              break;
  854.         case PC:
  855.              e->br_sup = 0;
  856.         case ZPC:
  857.              e->type = PCINDEX;
  858.              break;
  859.         default:
  860.              error("Base register expected");
  861.              e->type = EMPTY;
  862.              break;
  863.              }
  864.         }
  865.     if( base==xreg && (idx[xreg].i_type==PC || idx[xreg].i_type==ZPC)){
  866.         /* ([PC]) or ([ZPC]) */
  867.         e->type = PCINDEX;
  868.         if( idx[xreg].i_type == PC )
  869.             e->br_sup = 0;
  870.         return;
  871.         }
  872.  
  873.     /* remaining item is Xreg */
  874.     switch( idx[xreg].i_type ){
  875.     case AREG:
  876.         e->xn_sup = 0;
  877.     case ZAREG:
  878.         e->stat2 = 1;   /* remember that Xn is an AREG */
  879.         break;
  880.     case DREG:
  881.         e->xn_sup = 0;
  882.     case ZDREG:
  883.         break;
  884.     default:
  885.         error("Index Register Expected");
  886.         e->type = EMPTY;
  887.         break;
  888.         }
  889.     e->siz = idx[xreg].i_siz;
  890.     e->scl = idx[xreg].i_scale;
  891.     e->reg2 = idx[xreg].i_val;
  892.     if( xreg > iflag )
  893.         e->prepst = 1;  /* post indexing */
  894. #endif
  895. #ifdef M68HC16
  896.     error("Indirect addressing not supported");
  897.     e->type = EMPTY;
  898. #endif
  899. }
  900.  
  901. /*
  902.  *      dump_comp --- display composite EA classes
  903.  */
  904. dump_comp()
  905. {
  906.     int i;
  907.     int j;
  908.     unsigned mask;
  909.  
  910.     printf("Composite EA classes:\n");
  911.     for(i=RN; i<MULTI; i++ ){
  912.         printf("%s:\t",eanames[i]);
  913.         mask = eatab[i-RN];
  914.         j = 0;
  915.         while(mask){
  916.             if( mask&1)
  917.                 printf("%s ",eanames[j]);
  918.             j++;
  919.             mask >>= 1;
  920.             }
  921.         printf("\n");
  922.         }
  923.     printf("\n");
  924. }
  925.  
  926. /*
  927.  *      dump_mne --- display mnemonic/template tables
  928.  */
  929. dump_mne()
  930. {
  931.     struct mne *m;
  932.     struct tmpl *t;
  933.     int     i,j;
  934.     extern struct mne mnemonic[];
  935.     extern struct tmpl template[];
  936.     extern int Nmne;
  937.  
  938.     printf("Legal mnemonic/size/ea combinations:\n");
  939.     for( m =mnemonic; m < &mnemonic[Nmne]; m++ ){
  940.         printf("%s",m->mne_name);
  941.         t = m->ptmpl;
  942.         i = m->ntmpl;
  943.         while(i--){
  944.             printf("\t");
  945.             psize(t->sizes);
  946.             for(j=0;j<4;j++){
  947.                 if( t->modes[j] == EMPTY )
  948.                     break;
  949.                 printf("\t%s",eanames[t->modes[j]]);
  950.                 }
  951.             printf("\n");
  952.             t++;
  953.             }
  954.         }
  955.     printf("\n");
  956. }
  957.  
  958. psize(s)
  959. int s;
  960. {
  961.     if( s&B )printf("b");
  962.     if( s&W )printf("w");
  963.     if( s&L )printf("l");
  964.     if( s&S )printf("s");
  965.     if( s&D )printf("d");
  966.     if( s&X )printf("x");
  967.     if( s&P )printf("p");
  968.     if( s&U )printf("u");
  969. }
  970.